home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / nfsmount / RCS / nfsIO.c,v < prev    next >
Text File  |  1991-09-10  |  25KB  |  998 lines
  1. head     1.13;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.13
  10. date     91.09.10.19.24.27;  author mottsmth;  state Exp;
  11. branches ;
  12. next     1.12;
  13.  
  14. 1.12
  15. date     90.02.06.17.50.00;  author brent;  state Exp;
  16. branches ;
  17. next     1.11;
  18.  
  19. 1.11
  20. date     89.10.10.13.15.23;  author brent;  state Exp;
  21. branches ;
  22. next     1.10;
  23.  
  24. 1.10
  25. date     89.09.20.17.42.14;  author douglis;  state Exp;
  26. branches ;
  27. next     1.9;
  28.  
  29. 1.9
  30. date     89.06.30.10.29.17;  author brent;  state Exp;
  31. branches ;
  32. next     1.8;
  33.  
  34. 1.8
  35. date     89.06.02.13.55.23;  author brent;  state Exp;
  36. branches ;
  37. next     1.7;
  38.  
  39. 1.7
  40. date     89.05.31.15.21.30;  author brent;  state Exp;
  41. branches ;
  42. next     1.6;
  43.  
  44. 1.6
  45. date     89.02.02.16.35.23;  author brent;  state Exp;
  46. branches ;
  47. next     1.5;
  48.  
  49. 1.5
  50. date     89.02.02.15.04.59;  author brent;  state Exp;
  51. branches ;
  52. next     1.4;
  53.  
  54. 1.4
  55. date     89.01.13.10.48.24;  author brent;  state Exp;
  56. branches ;
  57. next     1.3;
  58.  
  59. 1.3
  60. date     88.11.14.15.14.49;  author brent;  state Exp;
  61. branches ;
  62. next     1.2;
  63.  
  64. 1.2
  65. date     88.11.11.11.33.06;  author brent;  state Exp;
  66. branches ;
  67. next     1.1;
  68.  
  69. 1.1
  70. date     88.11.02.12.44.11;  author brent;  state Exp;
  71. branches ;
  72. next     ;
  73.  
  74.  
  75. desc
  76. @NFS I/O routines
  77. @
  78.  
  79.  
  80. 1.13
  81. log
  82. @Cleanup memory leaks.
  83. @
  84. text
  85. @/*
  86.  * nfsIO.c --
  87.  * 
  88.  *    I/O procedures for NFS files.
  89.  *
  90.  * Copyright 1988 Regents of the University of California
  91.  * Permission to use, copy, modify, and distribute this
  92.  * software and its documentation for any purpose and without
  93.  * fee is hereby granted, provided that the above copyright
  94.  * notice appear in all copies.  The University of California
  95.  * makes no representations about the suitability of this
  96.  * software for any purpose.  It is provided "as is" without
  97.  * express or implied warranty.
  98.  */
  99. #ifndef lint
  100. static char rcsid[] = "$Header: /sprite/src/cmds/nfsmount/RCS/nfsIO.c,v 1.12 90/02/06 17:50:00 brent Exp Locker: mottsmth $ SPRITE (Berkeley)";
  101. #endif not lint
  102.  
  103. #include "stdio.h"
  104.  
  105. #include "nfs.h"
  106. #include "sys/stat.h"
  107. #include "kernel/fsdm.h"
  108. #include "sig.h"
  109.  
  110.  
  111. /*
  112.  * Service switch that the pdev library will use for the pseudo-device
  113.  * connections to each NFS file.
  114.  */
  115. Pdev_CallBacks nfsFileService = {
  116.     NULL,             /* PDEV_OPEN - only for pseudo-devices */
  117.     NfsRead,            /* PDEV_READ */
  118.     NfsWrite,            /* PDEV_WRITE */
  119.     NfsIoctl,            /* PDEV_IOCTL */
  120.     NfsClose,             /* PDEV_CLOSE */
  121.     NfsGetAttrStream,        /* PDEV_GET_ATTR - called on open pfs streams */
  122.     NfsSetAttrStream,        /* PDEV_SET_ATTR - called on open pfs streams */
  123. };
  124.  
  125.  
  126.  
  127. /*
  128.  *----------------------------------------------------------------------
  129.  *
  130.  * NfsClose --
  131.  *
  132.  *    Default procedure is called when an PDEV_CLOSE request is
  133.  *    received over an service stream.
  134.  *
  135.  * Results:
  136.  *    Returns SUCCESS and the select state of the pseudo-device.
  137.  *
  138.  * Side effects:
  139.  *    Free's up the handle slot used to remember the open file.
  140.  *
  141.  *----------------------------------------------------------------------
  142.  */
  143. /*ARGSUSED*/
  144. int
  145. NfsClose(streamPtr)
  146.     Pdev_Stream *streamPtr;
  147. {
  148.     register Fs_FileID *fileIDPtr = (Fs_FileID *)streamPtr->clientData;
  149.     register nfs_fh *handlePtr;
  150.     register int status = SUCCESS;
  151.  
  152.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsFileTableSize) {
  153.     if (nfsFileTable[fileIDPtr->minor] != (NfsOpenFile *)NULL) {
  154.         free((char *)nfsFileTable[fileIDPtr->minor]->handlePtr);
  155.         AUTH_DESTROY(nfsFileTable[fileIDPtr->minor]->authPtr);
  156.         free((char *)nfsFileTable[fileIDPtr->minor]);
  157.         nfsFileTable[fileIDPtr->minor] = (NfsOpenFile *)NULL;
  158.     } else {
  159.         printf("NfsClose: no open file for file ID <%d,%d,%d,%d>\n",
  160.         fileIDPtr->type,
  161.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  162.         status = EINVAL;
  163.     }
  164.     free((char *)fileIDPtr);
  165.     } else {
  166.     printf("NfsClose: bad fileID <%d,%d,%d,%d>\n", fileIDPtr->type,
  167.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  168.     status = EINVAL;
  169.     }
  170.     return(status);
  171. }
  172.  
  173. /*
  174.  *----------------------------------------------------------------------
  175.  *
  176.  * NfsRead --
  177.  *
  178.  *    Read from an NFS file.
  179.  *
  180.  * Results:
  181.  *    The number of bytes read.
  182.  *
  183.  * Side effects:
  184.  *    Do the read.
  185.  *
  186.  *----------------------------------------------------------------------
  187.  */
  188. /*ARGSUSED*/
  189. int
  190. NfsRead(streamPtr, readPtr, freeItPtr, selectBitsPtr, sigPtr)
  191.     Pdev_Stream *streamPtr;    /* Private data */
  192.     Pdev_RWParam *readPtr;    /* Return - how much data was generated */
  193.     Boolean *freeItPtr;        /* In/Out indicates if *bufferPtr is malloc'd */
  194.     int *selectBitsPtr;        /* Return - the select state of the pdev */
  195.     Pdev_Signal *sigPtr;    /* Return - signal to return, if any */
  196. {
  197.     register Fs_FileID *fileIDPtr = (Fs_FileID *)streamPtr->clientData;
  198.     register nfs_fh *handlePtr;
  199.     register int status = NFS_OK;
  200.     register int bytesToRead = readPtr->length;
  201.     register int toRead;
  202.     register Address buffer = readPtr->buffer;
  203.     NfsState *nfsPtr;
  204.     readargs readArgs;
  205.     readres readResult;
  206.  
  207.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsFileTableSize) {
  208.     handlePtr = nfsFileTable[fileIDPtr->minor]->handlePtr;
  209.     nfsPtr = (NfsState *)fileIDPtr->serverID;
  210.     nfsPtr->nfsClnt->cl_auth = nfsFileTable[fileIDPtr->minor]->authPtr;
  211.     if (fileIDPtr->type == TYPE_FILE) {
  212.         /*
  213.          * Reading from a regular file.  Use standard read RPC.
  214.          * Tell the XDR routines about our pre-allocated buffer.
  215.          */
  216.         readPtr->length = 0;
  217.         readArgs.totalcount = 0;    /* unused by protocol */
  218.         bcopy((char *)handlePtr, (char *)&readArgs.file, sizeof(nfs_fh));
  219.         while (bytesToRead > 0 && status == NFS_OK) {
  220.         toRead = (bytesToRead > NFS_MAXDATA) ? NFS_MAXDATA :
  221.                             bytesToRead;
  222.         readResult.readres_u.reply.data.data_len = toRead;
  223.         readResult.readres_u.reply.data.data_val = buffer;
  224.     
  225.         readArgs.offset = readPtr->offset;
  226.         readArgs.count = toRead;
  227.     
  228.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_READ, xdr_readargs,
  229.             &readArgs, xdr_readres, &readResult, nfsTimeout)
  230.                 != RPC_SUCCESS) {
  231.             clnt_perror(nfsPtr->nfsClnt, "NFSPROC_READ");
  232.             status = EINVAL;
  233.         } else {
  234.             status = readResult.status;
  235.             if (status == NFS_OK) {
  236.             if (toRead > readResult.readres_u.reply.data.data_len) {
  237.                 /*
  238.                  * Short read.
  239.                  */
  240.                 readPtr->length +=
  241.                 readResult.readres_u.reply.data.data_len;
  242.                 break;
  243.             } else {
  244.                 toRead = readResult.readres_u.reply.data.data_len;
  245.                 readPtr->length += toRead;
  246.                 readPtr->offset += toRead;
  247.                 buffer += toRead;
  248.                 bytesToRead -= toRead;
  249.             }
  250.             } else {
  251.             status = NfsStatusMap(status);
  252.             }
  253.         }
  254.         }
  255.     } else if (fileIDPtr->type == TYPE_SYMLINK) {
  256.         /*
  257.          * Use the NFS READLINK procedure to read the link value.
  258.          */
  259.         readlinkres        readLinkResult;
  260.  
  261.         readLinkResult.readlinkres_u.data = buffer;
  262.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_READLINK, xdr_nfs_fh,
  263.             handlePtr, xdr_readlinkres,
  264.             &readLinkResult, nfsTimeout) != RPC_SUCCESS) {
  265.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_READLINK");
  266.         status = EINVAL;
  267.         } else {
  268.         status = readLinkResult.status;
  269.         if (status == NFS_OK) {
  270.             readPtr->length = strlen(readLinkResult.readlinkres_u.data);
  271.         } else {
  272.             status = NfsStatusMap(status);
  273.         }
  274.         }
  275.     } else {
  276.         /*
  277.          * We have to use the NFS READDIR procedure to read a directory.
  278.          * There are two tricks required.  First we have to
  279.          * save the nfscookie that is returned by the READDIR so we can
  280.          * use it again on the next call to read from the directory.  This
  281.          * trick only works with sequential reading of directories.  The
  282.          * second trick is no biggie, we just have to convert from the
  283.          * linked list returned by the XDR routines to a Sprite format
  284.          * directory.
  285.          */
  286.         readdirargs readDirArgs;
  287.         readdirres readDirResult;
  288.  
  289.         bcopy((char *)handlePtr, (char *)&readDirArgs.dir, sizeof(nfs_fh));
  290.         if (readPtr->offset == 0) {
  291.         bzero((char *)&readDirArgs.cookie, sizeof(nfscookie));
  292.         } else {
  293.         NfsFindCookie(fileIDPtr, readPtr->offset, &readDirArgs.cookie);
  294.         }
  295.         readDirArgs.count = readPtr->length;
  296.         bzero((char *)&readDirResult, sizeof(readdirres));
  297.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_READDIR, xdr_readdirargs,
  298.             &readDirArgs, xdr_readdirres, &readDirResult, nfsTimeout)
  299.                 != RPC_SUCCESS) {
  300.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_READDIR");
  301.         status = EINVAL;
  302.         readPtr->length = 0;
  303.         } else {
  304.         status = readDirResult.status;
  305.         if (status != NFS_OK) {
  306.             status = NfsStatusMap(status);
  307.             readPtr->length = 0;
  308.         } else {
  309.             NfsToSpriteDirectory(&readDirResult.readdirres_u.reply,
  310.             readPtr->offset, &readPtr->length, buffer, fileIDPtr);
  311.         }
  312.         }
  313.     }
  314.     } else {
  315.     printf("NfsRead: bad fileID <%d,%d,%d,%d>\n", fileIDPtr->type,
  316.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  317.     readPtr->length = 0;
  318.     status = EINVAL;
  319.     }
  320.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  321.     return(status);
  322. }
  323.  
  324. /*
  325.  *----------------------------------------------------------------------
  326.  *
  327.  * NfsWrite --
  328.  *
  329.  *    Write to an NFS file.  This is a thin layer on top of the
  330.  *    basic RPC.  This could be enhanced to pass the data block
  331.  *    off to a subordinate writing process.
  332.  *
  333.  * Results:
  334.  *    None.
  335.  *
  336.  * Side effects:
  337.  *    None.
  338.  *
  339.  *----------------------------------------------------------------------
  340.  */
  341.  
  342. /*ARGSUSED*/
  343. int
  344. NfsWrite(streamPtr, async, writePtr, selectBitsPtr, sigPtr)
  345.     Pdev_Stream *streamPtr;    /* Private data */
  346.     int async;            /* ought not to be TRUE in NFS! */
  347.     Pdev_RWParam *writePtr;    /* Information about the write and writer */
  348.     int *selectBitsPtr;        /* Result - select state of the pseudo-device */
  349.     Pdev_Signal *sigPtr;    /* Result - signal to return, if any */
  350. {
  351.     register Fs_FileID *fileIDPtr = (Fs_FileID *)streamPtr->clientData;
  352.     register nfs_fh *handlePtr;
  353.     NfsState *nfsPtr;
  354.     register int status = NFS_OK;
  355.     register int bytesToWrite;
  356.     register int toWrite;
  357.     int openFlags;
  358.     writeargs writeArgs;
  359.     attrstat attrStat;
  360.  
  361.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsFileTableSize) {
  362.     handlePtr = nfsFileTable[fileIDPtr->minor]->handlePtr;
  363.     openFlags = nfsFileTable[fileIDPtr->minor]->openFlags;
  364.     nfsPtr = (NfsState *)fileIDPtr->serverID;
  365.     nfsPtr->nfsClnt->cl_auth = nfsFileTable[fileIDPtr->minor]->authPtr;
  366.  
  367.     if (openFlags & FS_APPEND) {
  368.         /*
  369.          * Find out how big the file in order to approximate
  370.          * append-mode writing.
  371.          */
  372.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_GETATTR, xdr_nfs_fh,
  373.             handlePtr, xdr_attrstat, &attrStat, nfsTimeout)
  374.                 != RPC_SUCCESS) {
  375.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_GETATTR");
  376.         status = FAILURE;
  377.         goto exit;
  378.         } else {
  379.         status = attrStat.status;
  380.         if (status == NFS_OK) {
  381.             writePtr->offset = attrStat.attrstat_u.attributes.size;
  382.         } else {
  383.             status = NfsStatusMap(status);
  384.             goto exit;
  385.         }
  386.         }
  387.     }
  388.     bcopy((char *)handlePtr, (char *)&writeArgs.file, sizeof(nfs_fh));
  389.     bytesToWrite = writePtr->length;
  390.     writePtr->length = 0;
  391.     writeArgs.beginoffset = 0;    /* unused by NFS protocol */
  392.     writeArgs.totalcount = 0;    /* unused by NFS protocol */
  393.     while (bytesToWrite > 0 && status == NFS_OK) {
  394.         writeArgs.offset = writePtr->offset;
  395.         toWrite = (bytesToWrite > NFS_MAXDATA) ? NFS_MAXDATA : bytesToWrite;
  396.         writeArgs.data.data_len = toWrite;
  397.         writeArgs.data.data_val = writePtr->buffer;
  398.     
  399.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_WRITE, xdr_writeargs,
  400.             &writeArgs, xdr_attrstat, &attrStat, nfsTimeout)
  401.             != RPC_SUCCESS) {
  402.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_WRITE");
  403.         status = EINVAL;
  404.         } else {
  405.         status = attrStat.status;
  406.         if (status != NFS_OK) {
  407.             status = NfsStatusMap(status);
  408.         } else {
  409.             NfsCacheAttributes(fileIDPtr,
  410.                     &attrStat.attrstat_u.attributes);
  411.             bytesToWrite -= toWrite;
  412.             writePtr->buffer += toWrite;
  413.             writePtr->length += toWrite;
  414.             writePtr->offset += toWrite;
  415.         }
  416.         }
  417.     }
  418.     if (async && (bytesToWrite > 0)) {
  419.         fprintf(stderr, "Warning: short async NFS write\n");
  420.     }
  421.     } else {
  422.     printf("NfsWrite: bad fileID <%d,%d,%d,%d>\n", fileIDPtr->type,
  423.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  424.     writePtr->length = 0;
  425.     status = EINVAL;
  426.     }
  427. exit:
  428.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  429.     return(status);
  430. }
  431.  
  432. /*
  433.  *----------------------------------------------------------------------
  434.  *
  435.  * NfsIoctl --
  436.  *
  437.  *    Take special actions on an NFS file.  This handles truncation,
  438.  *    and could be modified to handle locking, some day, some how.
  439.  *
  440.  * Results:
  441.  *    IOC_TRUNCATE maps to a SetAttributes with a short size.
  442.  *
  443.  * Side effects
  444.  *    None to internal data structure.  The I/O controls have various
  445.  *    effects on NFS files.
  446.  *
  447.  *----------------------------------------------------------------------
  448.  */
  449. /*ARGSUSED*/
  450. int
  451. NfsIoctl(streamPtr, ioctlPtr, selectBitsPtr, sigPtr)
  452.     Pdev_Stream *streamPtr;
  453.     Pdev_IOCParam *ioctlPtr;
  454.     int *selectBitsPtr;
  455.     Pdev_Signal *sigPtr;
  456. {
  457.     register Fs_FileID *fileIDPtr = (Fs_FileID *)streamPtr->clientData;
  458.     register nfs_fh *handlePtr;
  459.     NfsState *nfsPtr;
  460.     attrstat attrStat;
  461.     int status;
  462.  
  463.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsFileTableSize) {
  464.     handlePtr = nfsFileTable[fileIDPtr->minor]->handlePtr;
  465.     nfsPtr = (NfsState *)fileIDPtr->serverID;
  466.     nfsPtr->nfsClnt->cl_auth = nfsFileTable[fileIDPtr->minor]->authPtr;
  467.  
  468.     switch (ioctlPtr->command) {
  469.         case IOC_PDEV_SIGNAL_OWNER: {
  470.         /*
  471.          * Special test of IOC_PDEV_SIGNAL_REPLY.
  472.          * We have the user program ask for it!
  473.          */
  474.         sigPtr->signal = SIG_SUSPEND;
  475.         sigPtr->code = SIG_NO_CODE;
  476.         status = SUCCESS;
  477.         break;
  478.         }
  479.         case IOC_TRUNCATE: {
  480.         sattrargs sattrArgs;
  481.  
  482.         if (ioctlPtr->inBufSize < sizeof(int) ||
  483.             ioctlPtr->inBuffer == NULL) {
  484.             status = GEN_INVALID_ARG;
  485.             break;
  486.         }
  487.         bcopy((char *)handlePtr, (char *)&sattrArgs.file,
  488.             sizeof(nfs_fh));
  489.         sattrArgs.attributes.mode = -1;
  490.         sattrArgs.attributes.uid = -1;
  491.         sattrArgs.attributes.gid = -1;
  492.         sattrArgs.attributes.size = *(int *)ioctlPtr->inBuffer;
  493.         sattrArgs.attributes.atime.seconds = -1;
  494.         sattrArgs.attributes.atime.useconds = -1;
  495.         sattrArgs.attributes.mtime.seconds = -1;
  496.         sattrArgs.attributes.mtime.useconds = -1;
  497.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_SETATTR, xdr_sattrargs,
  498.                 &sattrArgs, xdr_attrstat, &attrStat, nfsTimeout)
  499.                 != RPC_SUCCESS) {
  500.             clnt_perror(nfsPtr->nfsClnt, "NFSPROC_SETATTR");
  501.             status = EINVAL;
  502.         } else {
  503.             status = NfsStatusMap((int) attrStat.status);
  504.         }
  505.         break;
  506.         }
  507.         case IOC_GET_FLAGS:
  508.         case IOC_SET_FLAGS:
  509.         case IOC_SET_BITS:
  510.         case IOC_CLEAR_BITS:
  511.         case IOC_REPOSITION:
  512.         case IOC_GET_OWNER:
  513.         case IOC_SET_OWNER:
  514.         case IOC_WRITE_BACK:
  515.         status = SUCCESS;
  516.         break;
  517.         case IOC_LOCK:
  518.         case IOC_UNLOCK:
  519.         case IOC_MAP:
  520.         case IOC_NUM_READABLE:
  521.         default:
  522.         status = GEN_NOT_IMPLEMENTED;
  523.         break;
  524.     }
  525.     } else {
  526.     printf("NfsIoctl: bad fileID <%d,%d,%d,%d>\n", fileIDPtr->type,
  527.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  528.     }
  529.     ioctlPtr->outBufSize = 0;
  530.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  531.     return(status);
  532. }
  533. @
  534.  
  535.  
  536. 1.12
  537. log
  538. @Added support for IOC_WRITE_BACK
  539. @
  540. text
  541. @d16 1
  542. a16 1
  543. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.11 89/10/10 13:15:23 brent Exp $ SPRITE (Berkeley)";
  544. d71 1
  545. a71 1
  546.         free((char *)nfsFileTable[fileIDPtr->minor]->authPtr);
  547. @
  548.  
  549.  
  550. 1.11
  551. log
  552. @Fixed include
  553. @
  554. text
  555. @d16 1
  556. a16 1
  557. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.10 89/09/20 17:42:14 douglis Exp Locker: brent $ SPRITE (Berkeley)";
  558. d430 1
  559. @
  560.  
  561.  
  562. 1.10
  563. log
  564. @Removed lint
  565. @
  566. text
  567. @d16 1
  568. a16 1
  569. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.9 89/06/30 10:29:17 brent Exp Locker: douglis $ SPRITE (Berkeley)";
  570. d23 1
  571. a23 1
  572. #include "kernel/fsDisk.h"
  573. @
  574.  
  575.  
  576. 1.9
  577. log
  578. @Implemented append-mode writes
  579. @
  580. text
  581. @d16 1
  582. a16 1
  583. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.8 89/06/02 13:55:23 brent Exp Locker: brent $ SPRITE (Berkeley)";
  584. d419 1
  585. a419 1
  586.             status = NfsStatusMap(attrStat.status);
  587. @
  588.  
  589.  
  590. 1.8
  591. log
  592. @Updated for new pseudo-device interface
  593. @
  594. text
  595. @d16 1
  596. a16 1
  597. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.7 89/05/31 15:21:30 brent Exp $ SPRITE (Berkeley)";
  598. d273 1
  599. d279 1
  600. d283 21
  601. d343 1
  602. @
  603.  
  604.  
  605. 1.7
  606. log
  607. @Fixed a core leak with the SUN-RPC authentication information
  608. @
  609. text
  610. @d16 1
  611. a16 1
  612. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.6 89/02/02 16:35:23 brent Exp $ SPRITE (Berkeley)";
  613. d106 3
  614. a108 8
  615. NfsRead(streamPtr, offset, procID, familyID, amountReadPtr, bufferPtr, freeItPtr,
  616.         selectBitsPtr)
  617.     Pdev_Stream *streamPtr;        /* Private data */
  618.     int offset;            /* Byte offset at which to read */
  619.     int procID;            /* Family ID of calling process */
  620.     int familyID;        /* Family ID of calling process */
  621.     int *amountReadPtr;        /* Return - how much data was generated */
  622.     Address *bufferPtr;        /* Ref. to buffer we fill in with data bytes */
  623. d111 1
  624. d116 1
  625. a116 1
  626.     register int bytesToRead = *amountReadPtr;
  627. d118 1
  628. a118 1
  629.     register Address buffer = *bufferPtr;
  630. d132 1
  631. a132 1
  632.         *amountReadPtr = 0;
  633. d141 1
  634. a141 1
  635.         readArgs.offset = offset;
  636. d156 1
  637. a156 1
  638.                 *amountReadPtr +=
  639. d161 2
  640. a162 1
  641.                 *amountReadPtr += toRead;
  642. a163 1
  643.                 offset += toRead;
  644. d186 1
  645. a186 1
  646.             *amountReadPtr = strlen(readLinkResult.readlinkres_u.data);
  647. d206 1
  648. a206 1
  649.         if (offset == 0) {
  650. d209 1
  651. a209 1
  652.         NfsFindCookie(fileIDPtr, offset, &readDirArgs.cookie);
  653. d211 1
  654. a211 1
  655.         readDirArgs.count = *amountReadPtr;
  656. d218 1
  657. a218 1
  658.         *amountReadPtr = 0;
  659. d223 1
  660. a223 1
  661.             *amountReadPtr = 0;
  662. d226 1
  663. a226 1
  664.                 offset, amountReadPtr, *bufferPtr, fileIDPtr);
  665. d233 1
  666. a233 1
  667.     *amountReadPtr = 0;
  668. d260 1
  669. a260 1
  670. NfsWrite(streamPtr, async, offset, procID, familyID, numBytesPtr, buffer, selectBitsPtr)
  671. d262 2
  672. a263 6
  673.     int async;            /* ought not to be TRUE */
  674.     int offset;            /* Offset at which to write */
  675.     int procID;            /* Process ID of caller */
  676.     int familyID;        /* Calling process's family ID */
  677.     int *numBytesPtr;        /* In/Out byte count */
  678.     Address buffer;        /* Buffer containing bytes */
  679. d265 1
  680. d282 4
  681. a285 4
  682.     bytesToWrite = *numBytesPtr;
  683.     *numBytesPtr = 0;
  684.     writeArgs.beginoffset = 0;    /* unused by protocol */
  685.     writeArgs.totalcount = 0;    /* unused by protocol */
  686. d287 1
  687. a287 1
  688.         writeArgs.offset = offset;
  689. d290 1
  690. a290 1
  691.         writeArgs.data.data_val = buffer;
  692. a303 1
  693.             *numBytesPtr += toWrite;
  694. d305 3
  695. a307 2
  696.             offset += toWrite;
  697.             buffer += toWrite;
  698. d317 1
  699. a317 1
  700.     *numBytesPtr = 0;
  701. d343 1
  702. a343 1
  703. NfsIoctl(streamPtr, command, procID, familyID, byteOrder, inSize, inData, outSizePtr, outData, selectBitsPtr)
  704. d345 1
  705. a345 8
  706.     int command;
  707.     int procID;
  708.     int familyID;
  709.     int byteOrder;
  710.     int inSize;
  711.     Address inData;
  712.     int *outSizePtr;
  713.     Address outData;
  714. d347 1
  715. d360 1
  716. a360 1
  717.     switch (command) {
  718. d363 1
  719. a363 1
  720.          * Special test of IOC_PDEV_SIGNAL.
  721. d366 3
  722. a368 5
  723.         Pdev_Signal signal;
  724.         signal.signal = SIG_SUSPEND;
  725.         signal.code = SIG_NO_CODE;
  726.         status = Fs_IOControl(streamPtr->streamID,IOC_PDEV_SIGNAL_OWNER,
  727.             sizeof(Pdev_Signal), &signal, 0, NULL);
  728. d374 2
  729. a375 1
  730.         if (inSize < sizeof(int) || inData == NULL) {
  731. d384 1
  732. a384 1
  733.         sattrArgs.attributes.size = *(int *)inData;
  734. d420 1
  735. a420 1
  736.     *outSizePtr = 0;
  737. @
  738.  
  739.  
  740. 1.6
  741. log
  742. @Fixed readlink()
  743. @
  744. text
  745. @d16 1
  746. a16 1
  747. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.5 89/02/02 15:04:59 brent Exp $ SPRITE (Berkeley)";
  748. d71 1
  749. @
  750.  
  751.  
  752. 1.5
  753. log
  754. @Updated to new pfs package.
  755. @
  756. text
  757. @d16 1
  758. a16 1
  759. static char rcsid[] = "$Header: /a/newcmds/nfsmount/RCS/nfsIO.c,v 1.4 89/01/13 10:48:24 brent Exp $ SPRITE (Berkeley)";
  760. d174 20
  761. d197 1
  762. a197 1
  763.          * There are two tricks required.  The first is that we have to
  764. @
  765.  
  766.  
  767. 1.4
  768. log
  769. @Implemented truncation
  770. @
  771. text
  772. @d16 1
  773. a16 1
  774. static char rcsid[] = "$Header: /a/newcmds/nfssrv/RCS/nfsIO.c,v 1.3 88/11/14 15:14:49 brent Exp $ SPRITE (Berkeley)";
  775. d24 1
  776. d31 1
  777. a31 2
  778. IntProc nfsFileService[] = {
  779.     NULL,             /* PDEV_INVALID */
  780. a32 2
  781.     NULL,            /* PDEV_DUP  - obsolete */
  782.     NfsClose,             /* PDEV_CLOSE */
  783. d36 1
  784. a38 9
  785.     BadProc,            /* PFS_OPEN */
  786.     BadProc,            /* PFS_GET_ATTR */
  787.     BadProc,            /* PFS_SET_ATTR */
  788.     BadProc,            /* PFS_MAKE_DEVICE */
  789.     BadProc,            /* PFS_MAKE_DIR */
  790.     BadProc,            /* PFS_REMOVE */
  791.     BadProc,            /* PFS_REMOVE_DIR */
  792.     BadProc,            /* PFS_RENAME */
  793.     BadProc,            /* PFS_HARD_LINK */
  794. d60 3
  795. a62 3
  796. ReturnStatus
  797. NfsClose(private)
  798.     ClientData private;
  799. d64 1
  800. a64 1
  801.     register Fs_FileID *fileIDPtr = (Fs_FileID *)private;
  802. d77 1
  803. a77 1
  804.         status = FAILURE;
  805. d83 1
  806. a83 1
  807.     status = FAILURE;
  808. d104 2
  809. a105 2
  810. ReturnStatus
  811. NfsRead(private, offset, familyID, amountReadPtr, bufferPtr, freeItPtr,
  812. d107 1
  813. a107 1
  814.     ClientData private;        /* Private data */
  815. d109 1
  816. d116 1
  817. a116 1
  818.     register Fs_FileID *fileIDPtr = (Fs_FileID *)private;
  819. d151 1
  820. a151 1
  821.             status = FAILURE;
  822. d200 1
  823. a200 1
  824.         status = FAILURE;
  825. d217 1
  826. a217 1
  827.     status = FAILURE;
  828. d242 4
  829. a245 3
  830. ReturnStatus
  831. NfsWrite(private, offset, familyID, numBytesPtr, buffer, selectBitsPtr)
  832.     ClientData private;        /* Private data */
  833. d247 1
  834. d253 1
  835. a253 1
  836.     register Fs_FileID *fileIDPtr = (Fs_FileID *)private;
  837. d282 1
  838. a282 1
  839.         status = FAILURE;
  840. d297 3
  841. d304 1
  842. a304 1
  843.     status = FAILURE;
  844. d328 3
  845. a330 3
  846. ReturnStatus
  847. NfsIoctl(private, command, familyID, inSize, inData, outSizePtr, outData, selectBitsPtr)
  848.     ClientData private;
  849. d332 1
  850. d334 1
  851. d341 1
  852. a341 1
  853.     register Fs_FileID *fileIDPtr = (Fs_FileID *)private;
  854. d345 1
  855. a345 1
  856.     ReturnStatus status;
  857. d353 12
  858. d386 1
  859. a386 1
  860.             status = FAILURE;
  861. d397 2
  862. a402 2
  863.         case IOC_GET_OWNER:
  864.         case IOC_SET_OWNER:
  865. @
  866.  
  867.  
  868. 1.3
  869. log
  870. @Added user authentication
  871. @
  872. text
  873. @d16 1
  874. a16 1
  875. static char rcsid[] = "$Header: /a/newcmds/nfssrv/RCS/nfsIO.c,v 1.2 88/11/11 11:33:06 brent Exp Locker: brent $ SPRITE (Berkeley)";
  876. d345 3
  877. d351 48
  878. d405 1
  879. a405 1
  880.     return(SUCCESS);
  881. @
  882.  
  883.  
  884. 1.2
  885. log
  886. @Stable complete version
  887. @
  888. text
  889. @d16 1
  890. a16 1
  891. static char rcsid[] = "$Header: /sprite/users/brent/nfstest/RCS/nfsIO.c,v 1.1 88/11/02 12:44:11 brent Exp $ SPRITE (Berkeley)";
  892. d78 5
  893. a82 6
  894.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsHandleTableSize) {
  895.     handlePtr = nfsHandleTable[fileIDPtr->minor];
  896.     nfsHandleTable[fileIDPtr->minor] = (nfs_fh *)NULL;
  897.     free((char *)fileIDPtr);
  898.     if (handlePtr != (nfs_fh *)NULL) {
  899.         free((char *)handlePtr);
  900. d84 1
  901. a84 1
  902.         printf("NfsClose: no handle for file ID <%d,%d,%d,%d>\n",
  903. d89 1
  904. d135 2
  905. a136 2
  906.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsHandleTableSize) {
  907.     handlePtr = nfsHandleTable[fileIDPtr->minor];
  908. d138 1
  909. d261 1
  910. a261 1
  911.     register nfs_fh *handlePtr = nfsHandleTable[fileIDPtr->minor];
  912. d269 5
  913. a273 3
  914.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsHandleTableSize) {
  915.     handlePtr = nfsHandleTable[fileIDPtr->minor];
  916.     nfsPtr = (NfsState *)fileIDPtr->serverID;    
  917. d344 1
  918. a344 1
  919.     register nfs_fh *handlePtr = nfsHandleTable[fileIDPtr->minor];
  920. d346 2
  921. a347 2
  922.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsHandleTableSize) {
  923.     handlePtr = nfsHandleTable[fileIDPtr->minor];
  924. @
  925.  
  926.  
  927. 1.1
  928. log
  929. @Initial revision
  930. @
  931. text
  932. @d16 1
  933. a16 1
  934. static char rcsid[] = "$Header: fsPfs.c,v 6.0 88/10/11 15:52:49 brent Exp $ SPRITE (Berkeley)";
  935. d127 4
  936. a130 1
  937.     register int status;
  938. d132 2
  939. d143 2
  940. a144 5
  941.         readargs readArgs;
  942.         readres readResult;
  943.         readResult.readres_u.reply.data.data_len = *amountReadPtr;
  944.         readResult.readres_u.reply.data.data_val = *bufferPtr;
  945.     
  946. d146 14
  947. a159 13
  948.         readArgs.offset = offset;
  949.         readArgs.count = *amountReadPtr;
  950.         readArgs.totalcount = 0;    /* unused by protocol */
  951.     
  952.         if (clnt_call(nfsPtr->nfsClnt, NFSPROC_READ, xdr_readargs,&readArgs,
  953.             xdr_readres, &readResult, nfsTimeout) != RPC_SUCCESS) {
  954.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_READ");
  955.         *amountReadPtr = 0;
  956.         status = FAILURE;
  957.         } else {
  958.         status = readResult.status;
  959.         if (status == NFS_OK) {
  960.             *amountReadPtr = readResult.readres_u.reply.data.data_len;
  961. d161 19
  962. a179 2
  963.             *amountReadPtr = 0;
  964.             status = NfsStatusMap(status);
  965. d209 1
  966. d214 1
  967. d262 3
  968. a264 1
  969.     int status;
  970. d272 2
  971. a273 3
  972.     writeArgs.offset = offset;
  973.     writeArgs.data.data_len = *numBytesPtr;
  974.     writeArgs.data.data_val = buffer;
  975. d276 11
  976. a286 12
  977.  
  978.     if (clnt_call(nfsPtr->nfsClnt, NFSPROC_WRITE, xdr_writeargs,
  979.         &writeArgs, xdr_attrstat, &attrStat, nfsTimeout)
  980.             != RPC_SUCCESS) {
  981.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_WRITE");
  982.         *numBytesPtr = 0;
  983.         status = FAILURE;
  984.     } else {
  985.         status = attrStat.status;
  986.         if (status != NFS_OK) {
  987.         *numBytesPtr = 0;
  988.         status = NfsStatusMap(status);
  989. d288 12
  990. a299 6
  991.         /*
  992.          * It appears that NFS always write all the data, so
  993.          * we leave *numBytesPtr alone.
  994.          */
  995.         NfsCacheAttributes(fileIDPtr, &attrStat.attrstat_u.attributes);
  996.          }
  997. @
  998.